home *** CD-ROM | disk | FTP | other *** search
/ Pascal Super Library / Pascal Super Library (CW International)(1997).bin / STRINGS / TPSTR7 / EXAM32.PAS < prev    next >
Pascal/Delphi Source File  |  1993-03-15  |  7KB  |  160 lines

  1. Program Exam32;
  2.  
  3. {**************************************************************************}
  4. {                                                                          }
  5. { Ce programme démontre les possibilités de ?Trim?.                        }
  6. {                                                                          }
  7. {**************************************************************************}
  8.  
  9. Uses
  10.   TpStr;
  11.  
  12. Var
  13.   S1 ,
  14.   S2 : String;
  15.  
  16. {  ---------------------------------------------------------------         }
  17. {  Procedure   ATrim(Var Str1: String);                                    }
  18. {  ---------------------------------------------------------------         }
  19. {                                                                          }
  20. {  Effet     : Supprime tous les caractères espaces de la chaîne <Str1>.   }
  21. {                                                                          }
  22. {  Usage     : Chaîne pascal.                                              }
  23. {                                                                          }
  24. {  Vitesse   : 7800/s                                                      }
  25. {                                                                          }
  26. { -------------------------------------------------------------------------}
  27.  
  28. Procedure Test1;
  29. Begin
  30.   S1 := 'a b c d e f    ';
  31.   ATrim(S1);
  32.   S1 := '    a b c e f';
  33.   ATrim(S1);
  34.   S1 := 'abcdef';
  35.   ATrim(S1);
  36. end;
  37.  
  38. {  ---------------------------------------------------------------         }
  39. {  Function   ATrim_(Str1: String):String;                                 }
  40. {  ---------------------------------------------------------------         }
  41. {                                                                          }
  42. {  Effet     : Idem, transformé en fonction.                               }
  43. {                                                                          }
  44. {  Usage     : Chaîne pascal.                                              }
  45. {                                                                          }
  46. {  Vitesse   : 7800/s                                                      }
  47. {                                                                          }
  48. { -------------------------------------------------------------------------}
  49.  
  50. Procedure Test2;
  51. Begin
  52.   S1 := 'a b c d e f    ';
  53.   S2 := ATrim_(S1);
  54.   S1 := '    a b c e f';
  55.   S2 := ATrim_(S1);
  56.   S1 := 'abcdef';
  57.   S2 := ATrim_(S1);
  58. end;
  59.  
  60. {  ---------------------------------------------------------------         }
  61. {  Procedure   LTrim(Var Str1: String);                                    }
  62. {  ---------------------------------------------------------------         }
  63. {                                                                          }
  64. {  Effet     : Supprime tous les caractères espaces à gauche de la chaîne  }
  65. {              <Str1>.                                                     }
  66. {                                                                          }
  67. {  Usage     : Chaîne pascal.                                              }
  68. {                                                                          }
  69. {  Vitesse   : 7800/s                                                      }
  70. {                                                                          }
  71. { -------------------------------------------------------------------------}
  72.  
  73. Procedure Test3;
  74. Begin
  75.   S1 := 'a b c d e f    ';
  76.   LTrim(S1);
  77.   S1 := '    a b c e f';
  78.   LTrim(S1);
  79.   S1 := 'abcdef';
  80.   LTrim(S1);
  81. end;
  82.  
  83. {  ---------------------------------------------------------------         }
  84. {  Function   LTrim_(Str1: String):String;                                 }
  85. {  ---------------------------------------------------------------         }
  86. {                                                                          }
  87. {  Effet     : Idem, transformé en fonction.                               }
  88. {                                                                          }
  89. {  Usage     : Chaîne pascal.                                              }
  90. {                                                                          }
  91. {  Vitesse   : 7800/s                                                      }
  92. {                                                                          }
  93. { -------------------------------------------------------------------------}
  94.  
  95. Procedure Test4;
  96. Begin
  97.   S1 := 'a b c d e f    ';
  98.   S2 := LTrim_(S1);
  99.   S1 := '    a b c e f';
  100.   S2 := LTrim_(S1);
  101.   S1 := 'abcdef';
  102.   S2 := LTrim_(S1);
  103. end;
  104.  
  105. {  ---------------------------------------------------------------         }
  106. {  Procedure   RTrim(Var Str1: String);                                    }
  107. {  ---------------------------------------------------------------         }
  108. {                                                                          }
  109. {  Effet     : Supprime tous les caractères espaces à droite de la chaîne  }
  110. {              <Str1>.                                                     }
  111. {                                                                          }
  112. {  Usage     : Chaîne pascal.                                              }
  113. {                                                                          }
  114. {  Vitesse   : 7800/s                                                      }
  115. {                                                                          }
  116. { -------------------------------------------------------------------------}
  117.  
  118. Procedure Test5;
  119. Begin
  120.   S1 := 'a b c d e f    ';
  121.   RTrim(S1);
  122.   S1 := '    a b c e f';
  123.   RTrim(S1);
  124.   S1 := 'abcdef';
  125.   RTrim(S1);
  126. end;
  127.  
  128. {  ---------------------------------------------------------------         }
  129. {  Function   RTrim_(Str1: String):String;                                 }
  130. {  ---------------------------------------------------------------         }
  131. {                                                                          }
  132. {  Effet     : Idem, transformé en fonction.                               }
  133. {                                                                          }
  134. {  Usage     : Chaîne pascal.                                              }
  135. {                                                                          }
  136. {  Vitesse   : 7800/s                                                      }
  137. {                                                                          }
  138. { -------------------------------------------------------------------------}
  139.  
  140. Procedure Test6;
  141. Begin
  142.   S1 := 'a b c d e f    ';
  143.   S2 := RTrim_(S1);
  144.   S1 := '    a b c e f';
  145.   S2 := RTrim_(S1);
  146.   S1 := 'abcdef';
  147.   S2 := RTrim_(S1);
  148. end;
  149.  
  150. Begin
  151.   Test1;
  152.   Test2;
  153.   Test3;
  154.   Test4;
  155.   Test5;
  156.   Test6;
  157. End.
  158.  
  159. { -------------------------------------------------------------------------}
  160.